package com.cn.xcsharp.util;

import com.alibaba.fastjson.JSONArray;

import java.math.BigDecimal;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StrUtils {
    public static final String INFO_200="请求成功";
    public static final String INFO_400="api数据平台使用时间到期!";
    public static final String INFO_500="请求参数不符合格式!";
    public static final String INFO_501="请求异常!";//当请求处理报出异常，提示501
    public static final String INFO_601="无效TOKEN,请重新登录";
    public static final String INFO_602="登录失败";

    public static String getJson(List list){
        String json = JSONArray.toJSONString(list).toString();
        String msg="{\"state\":200,\"msg\":\"成功\",\"data\":"+json+"}";

        return msg;
    }
    public static String getJson1(List list){
        String json = JSONArray.toJSONString(list).toString();
        return json;
    }
    public static String getHashMapJson(HashMap map) {
        String string = "{";
        for (Iterator it = map.entrySet().iterator(); it.hasNext();) {
            Map.Entry e = (Map.Entry) it.next();
            string += "\"" + e.getKey() + "\":";
            string += "\"" + e.getValue() + "\",";
        }
        string = string.substring(0, string.lastIndexOf(","));
        string += "}";
        String msg="{\"state\":200,\"msg\":\"成功\",\"data\":"+string+"}";
        return msg;
    }
    public static String getHashMap1Json(HashMap map) {
        String string = "{";
        for (Iterator it = map.entrySet().iterator(); it.hasNext();) {
            Map.Entry e = (Map.Entry) it.next();
            string += "\"" + e.getKey() + "\":";
            string += "\"" + e.getValue() + "\",";
        }
        string = string.substring(0, string.lastIndexOf(","));
        string += "}";
        return string;
    }
    public static boolean getIntToBool(String str){
        if(str.equals("1")){
            return true;
        }else{
            return false;
        }
    }
    public static String getErrorJson(){
        String msg="{\"state\":501,\"msg\":\"请求失败\",\"data\":\"false\"}";

        return msg;
    }
    /**
     * 判断一个字符串是否为 null 或 空串 或 空白
     * @param source 需要判断的字符串
     * @return 当字符串为 null 或 为 空白、空串 时返回 true
     */
    public static boolean empty( String source ) {
        return source == null || source.trim().isEmpty()  ;
    }

    /**
     * 判断一个字符串是否不是null且不是空串、不是空白
     * @param source 需要判断的字符串
     * @return 当 字符串是不是null且不是空串也不是空白时返回 true
     */
    public static boolean notEmpty( String source ) {
        return source != null && source.trim().length() > 0 ;
    }

    /**
     * 判断一个字符串变量是否为 null
     * @param source 需要判断的字符串
     * @return 当 字符串变量 为 null 时返回 true
     */
    public static boolean isNull( String source ) {
        return source == null ;
    }

    /**
     * 判断一个字符串是否为 空串
     * @param source 需要判断的字符串
     * @return 当字符串中的值是 空串 或 空白 串时返回 true
     */
    public static boolean emptyString( String source ) {
        return ( source != null ) && source.length() == source.trim().length() ;
    }

    /**
     * 判断一个字符串是否为 空白 串
     * @param source 需要判断的字符串
     * @return 当字符串中的值是 空白 串时返回 true
     */
    public static boolean blank( String source ){
        return ( source != null ) && source.length() > source.trim().length()  ;
    }

    /**
     * 比较两个非空(不是null，不是空串、不是空白)字符串是否"相等"
     * @param one 第一个需要比较的字符串
     * @param theOther 另一个参与比较的字符串
     * @return 当 两个字符串 都不为空串 且 内容完全一致 (剔除首尾空白后、大小写也一致)时返回 true
     */
    public static boolean equals( String one , String theOther) {
        return equals(one, theOther,true,false);
    }

    /**
     * 比较两个字符串是否 "相等"
     * @param one 参与比较的第一个字符串
     * @param theOther 参与比较的另一个字符串
     * @param escapeSpace 是否需要剔除首尾空白 ( true 表示需要剔除首尾空白，false 表示不剔除 )
     * @param ignoreCase 是否忽略大小写 ( true 表示忽略大小写 ，false 表示不忽略大小写 )
     * @return
     */
    public static boolean equals( String one , String theOther , boolean escapeSpace , boolean ignoreCase) {

        if( one == null || theOther == null ){
            return false ;
        }

        if( escapeSpace ){
            one = one.trim();
            theOther = theOther.trim();
        }

        return ignoreCase ? one.equalsIgnoreCase( theOther ) : one.equals( theOther ) ;
    }


    /**
     * 对字符串进行MD5加密
     * @param source 需要加密的字符串
     * @return 返回加密后的字符串
     */
    public static final String MD5(String source){
        if(source != null){
            StringBuffer md5 = new StringBuffer();
            MessageDigest md = null;
            try{
                md = MessageDigest.getInstance("MD5");
                md.update(source.getBytes());
                byte[] mdBytes = md.digest();

                for(int i = 0;i < mdBytes.length;i++){
                    int temp;
                    if(mdBytes[i] < 0){
                        temp = 256+mdBytes[i];
                    }else{
                        temp = mdBytes[i];
                    }
                    if(temp < 16){
                        md5.append("0");
                    }
                    md5.append(Integer.toString(temp,16 ));
                }
            }catch(NoSuchAlgorithmException e){
                e.printStackTrace();
            }
            return md5.toString().toUpperCase();
        }
        return null;
    }
    /**
     * 检测邮箱合法性
     *
     * @param email
     * @return
     */
    public static boolean isEmail(String email) {
        if ((email == null) || (email.trim().length() == 0)) {
            return false;
        }
        String regEx = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}$";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(email.trim().toLowerCase());

        return m.find();
    }


    /**
     * 得到指定位数的小数
     * @param v
     * @param scale
     * @return
     */
    public static String getDecimals(Double v, int scale) {

        return String.format("%." + String.valueOf(scale) + "f", v);

    }
    /**
     * 根据Unicode编码完美的判断中文汉字和符号
     *
     * @param c
     * @return
     */
    private static boolean isChinese(char c) {
        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
        if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
                || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
                || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
                || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
                || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
                || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS
                || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION) {
            return true;
        }
        return false;
    }

    /**
     * 判断是否包含中文汉字
     *
     * @param strName
     * @return
     */
    public static boolean isChineseHave(String strName) {
        char[] ch = strName.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            char c = ch[i];
            if (isChinese(c)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断是否只有中文汉字
     *
     * @param strName
     * @return
     */
    public static boolean isChineseAll(String strName) {
        char[] ch = strName.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            char c = ch[i];
            if (!isChinese(c)) {
                return false;
            }
        }
        return true;
    }
    //string 转 double
    public static double strToDobule(String a){
        try{
            Double d= Double.parseDouble(a);
            BigDecimal bd = new BigDecimal(d);
            Double c = bd.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            return c;
        }catch (Exception e){
            return 0;
        }
    }
    //string 转 double
    public static boolean strToBoolean(double a,double b){
        try{
            if(a>=b){
                return true;
            }
            return false;
        }catch (Exception e){
            return false;
        }
    }
    public static String getZeroToStr(double str){
        if(str==0){
            return "-";
        }else{
            return str+"";
        }
    }
    //去掉double小数点后无效的0
    public static String doubleTrans(double dou){
        if(Math.round(dou)-dou==0){
            return String.valueOf((long)dou);
        }
        return String.valueOf(dou);
    }
    //四舍五入保留整数
    public static String DecimalFormat(double number){
        String ret = null;
        try {
            DecimalFormat df = new DecimalFormat("#");
            ret = df.format(number).toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ret;
    }
    //四舍五入保留小数点2位
    public static String DecimalFormat2(double number){
        String ret = null;
        try {
            DecimalFormat df = new DecimalFormat("0.00");
            ret = df.format(number).toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ret;
    }
    //string 转 int
    public static int strToInt(String a){
        try{
            if(a.equals("null")||a.equals(null)){
                return 0;
            }
//            Math.round()
            int b=Math.round(Float.parseFloat(a));
//            int b=Integer.parseInt(DecimalFormat(Double.parseDouble(a)));
//            int b=Integer.parseInt(a);
            return b;
        }catch (Exception e){
            return 0;
        }
    }
    //两数据相除,保留两位小数
    public static float csNum(int a,int b){
        try{
            float num= (float)a/b;
//            DecimalFormat df = new DecimalFormat("0.0000");//格式化小数
//            String s = df.format(num);//返回的是String类型
//
//            float c=a/b;
////            System.out.println(c);
            return num;
        }catch (Exception e){
            System.out.println(e);
            return 0;
        }
    }
    public static double csNum1(double a,double b){
        try{
            if(b==0){
                return 0;
            }
            double c=a/b;
            return c;
        }catch (Exception e){
            return 0;
        }
    }
    //string 转 double
    public static double strToDobule4(String a){
        try{
            Double d= Double.parseDouble(a);
            BigDecimal bd = new BigDecimal(d);
            Double c = bd.setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
            return c;
        }catch (Exception e){
            return 0;
        }
    }
    /**
     * 判断邮政编码
     *
     * @param str
     * @return
     */
    public static boolean isCard(String str) {
        Pattern p = Pattern.compile("[1-9]\\d{5}(?!\\d)");
        Matcher m = p.matcher(str);
        return m.matches();
    }

}
